home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / temp / vgp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-12  |  26.7 KB  |  1,226 lines  |  [TEXT/????]
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************
  21. * Likkai Ng NCSA May 1991
  22. * 
  23. * vgp.c
  24. * Part of the vertex-set interface.
  25. * VGROUPs are handled by routines in here.
  26. *
  27. *************************************************************************/
  28.  
  29. #include "vg.h"
  30.  
  31. /* ------------------------------------------------------------ */
  32. /* 
  33. *
  34. * G L O B A L S 
  35. *
  36. * These are the *only* globals in the vset interface!!  
  37. * They are used only for debugging.  No globals in other files. 
  38. * The 2 functions below turn debugging on and off.
  39. *
  40. */
  41.  
  42. PUBLIC    char         sjs[200];
  43. PUBLIC    int      vjv    =    0;
  44.  
  45. /*
  46. turn debug on 
  47. */
  48. PUBLIC void    setjj()              /*@-@*/
  49. { 
  50.     vjv=1; 
  51. }
  52.  
  53. /*
  54. turn debug off 
  55. */
  56. PUBLIC void setnojj()         /*@-@*/
  57. { 
  58.     vjv=0; 
  59. }
  60.  
  61.  
  62. /*
  63. * -------------------------------------------------------------------- 
  64. * PRIVATE  data structure and routines.
  65. * 
  66. * Info about all vgroups in the file are loaded into vgtab  at start;
  67. * and the vg field set to NULL until that vgroup is attached,
  68. * and reset back to NULL when that vgroup is detached. 
  69. * Info about all vdatas in the file are loaded into vstab  at start;
  70. * and the vs field set to NULL until that vdata is attached,
  71. * and reset back to NULL when that vdata is detached. 
  72. * -------------------------------------------------------------------- 
  73. */
  74.  
  75.  
  76. PRIVATE vfile_t  vfile [VFILEMAX];
  77. PRIVATE int      nvfile = 0;
  78.  
  79. /*
  80.   ***Only called by Get_vfile()***   
  81. loads vgtab table with info of all vgroups in file f.
  82. Will allocate a new vfile_t, then proceed to load vg instances.
  83. RETURNS -1 if error
  84. RETURNS INDEX into vfile[] if ok.
  85. */
  86. PRIVATE int Load_vfile (f)              /*@@*/
  87.  
  88. DF *f;
  89. {
  90.     DFdesc   d;
  91.     vfile_t    * vf;
  92.     vginstance_t  * v;
  93.     vsinstance_t  * w;
  94.     int returnval;
  95.  
  96.     if (vjv) {
  97.         sprintf(sjs,"@Load_vfile \n");
  98.         zj;
  99.     }
  100.  
  101.     /* allocate a new vfile_t structure */
  102.     if (nvfile >= VFILEMAX-1) RTNEG ("Load_vfile: full\n");
  103.  
  104.     returnval = nvfile;
  105.     vf = &vfile[nvfile];
  106.     nvfile++;
  107.  
  108.     vf->f            = f;
  109.  
  110.     /* load all the vg's  tag/refs from file */
  111.     vf->vgtabn    = -1;
  112.     vf->vgtabtail = &(vf->vgtab);
  113.  
  114.     vf->vgtab.ref      = -1;
  115.     vf->vgtab.nattach  = -1;
  116.     vf->vgtab.nentries = -1;
  117.     vf->vgtab.vg       = NULL;
  118.     vf->vgtab.next     = NULL;
  119.  
  120.     vf->vgtabn = 0;
  121.     DFsetfind(f,VGDESCTAG,DFREF_WILDCARD);
  122.  
  123.     while (1) {
  124.         if ( DFfind(f,&d) != 0) break;          /* no more vgs */
  125.         if (vjv) {
  126.             sprintf(sjs,"#LOADVGDIR:FOUND (%d) <%d/%d>\n ",
  127.                 vf->vgtabn, d.tag,d.ref);
  128.             zj;
  129.         }
  130.  
  131.         if (NULL == (v = (vginstance_t*) DFIgetspace(sizeof(vginstance_t))))
  132.             RTNEG ("Load_vfile: no more space\n");
  133.  
  134.         vf->vgtabtail->next    = v;
  135.         vf->vgtabtail            = v;
  136.         v->next        = NULL;
  137.         v->ref      = d.ref;
  138.         v->vg       = (VGROUP*) NULL; /* ie not attached yet */
  139.         v->nattach  = 0;
  140.         v->nentries = 0;
  141.         vf->vgtabn++;
  142.  
  143.     }
  144.  
  145.     /* load all the vs's  tag/refs from file */
  146.     vf->vstabn    = -1;
  147.     vf->vstabtail = &(vf->vstab);
  148.  
  149.     vf->vstab.ref      = -1;
  150.     vf->vstab.nattach  = -1;
  151.     vf->vstab.nvertices= -1;
  152.     vf->vstab.vs       = NULL;
  153.     vf->vstab.next     = NULL;
  154.  
  155.     vf->vstabn = 0;
  156.     DFsetfind(f,VSDESCTAG,DFREF_WILDCARD);
  157.  
  158.     while (1) {
  159.         if ( DFfind(f,&d) != 0) break;      /* no more vgs */
  160.         if (vjv) {
  161.             sprintf(sjs,"#LOADVSDIR:FOUND (%d) <%d/%d>\n ",
  162.                 vf->vstabn, d.tag,d.ref);
  163.             zj;
  164.         }
  165.         if (NULL == (w = (vsinstance_t*) DFIgetspace(sizeof(vsinstance_t))))
  166.             RTNEG ("Load_vfile: no more space\n");
  167.  
  168.         vf->vstabtail->next  = w;
  169.         vf->vstabtail        = w;
  170.         w->next     = NULL;
  171.         w->ref      = d.ref;
  172.         w->vs       = (VDATA*) NULL; /* ie not attached yet */
  173.         w->nattach  = 0;
  174.         w->nvertices= 0;
  175.         vf->vstabn++;
  176.  
  177.     }
  178.  
  179.     /* file may be incompatible with vset version 2.x. Need to check it */
  180.     if ( (0 == vf->vgtabn) && (0 == vf->vstabn) )
  181.         if ( 0 == vicheckcompat (f) ) { /* not compatible */
  182.             sprintf(sjs,"********************************************\n\n");
  183.             zj;
  184.             sprintf(sjs,"%cFile incompatible with vset version 2.0\n",7); 
  185.             zj;
  186.             sprintf(sjs,"%cFirst use the utility vcompat on this file\n",7); 
  187.             zj;
  188.             sprintf(sjs,"********************************************\n\n");
  189.             zj;
  190.             nvfile--;     /* delete the structure for that file */
  191.             RTNEG ("Load_vfile: incompatible file\n");
  192.         }
  193.  
  194.     /* otherwise, success */
  195.     return (returnval); /* ok, return the index  */
  196.  
  197. } /* Load_vfile */
  198.  
  199. /* returns the vfile pointer for file f, else NULL */
  200. vfile_t * Get_vfile (f)
  201. DF * f;
  202. {
  203.     int i, vfileno;
  204.  
  205.     /* loop thru vfile[], if found, return ptr */
  206.     for (i=0;i<nvfile;i++) if (vfile[i].f == f)    return(&vfile[i]);
  207.  
  208.     /* not found, try to load it */
  209.     vfileno = Load_vfile (f);
  210.  
  211.     if (-1 == vfileno) {
  212.         RTNULL("Get_vfile: cannot load file\n");
  213.     }
  214.     else
  215.         return( &vfile[vfileno]); /* ok, return vfile pointer */
  216.  
  217. } /* Get_vfile */
  218.  
  219. /* should be replaced by HDFopen() or such */
  220. PUBLIC void Vinitialize(f)
  221. DF * f; {
  222.   if (f!=NULL) Remove_vfile (f);
  223.   }
  224.  
  225.  
  226. PRIVATE void Remove_vfile (f)
  227. DF * f;
  228. {
  229.     int i;
  230.  
  231.     /* loop thru vfile[], if found, delete it */
  232.         for (i=0;i<nvfile;i++)
  233.             if (vfile[i].f == f) { vfile[i].f = NULL; break; }
  234.             }
  235. /* ==================================================================== */
  236.  
  237. /*
  238. * Looks thru vgtab for vgid and return the addr of the vg instance
  239. * where vgid is found.
  240. * RETURNS NULL if error or not found.
  241. * RETURNS vginstance_t pointer if ok.
  242. *
  243. */
  244.  
  245. vginstance_t * vginstance (f,vgid)             /*@@*/
  246. DF  *f;
  247. int vgid;
  248.  
  249. {
  250.     vginstance_t * v;
  251.     vfile_t      * vf;
  252.  
  253.     if (NULL== (vf = (vfile_t*) Get_vfile(f)))
  254.         RTNULL ("vginstance: no such file\n");
  255.  
  256.     v = vf->vgtab.next;
  257.     while (NULL != v) {
  258.         if (v->ref == vgid) return(v);
  259.         v = v->next;
  260.     }
  261.     return(NULL);
  262.  
  263. } /* vginstance */
  264.  
  265. /* 
  266. * Tests if a vgroup with id vgid is in the file's vgtab.
  267. * returns -1 if not found,
  268. * returns 1 if found.
  269. */
  270. int vexistvg (f,vgid)             /*@@*/
  271. DF  *f;
  272. int vgid;
  273. {
  274.     if (NULL== (vginstance_t *) vginstance(f,vgid))
  275.         return(-1);
  276.     else
  277.         return (1);
  278.  
  279. } /* vexistvg */
  280. /* ==================================================================== */
  281. /*
  282. * vpackvg() and vunpackvg() : Packing and unpacking routines.
  283. * For use in retrieving and storing vgroups to/from the HDF file.
  284. *
  285. *    Fields of VGROUP  that gets stored in HDF as a VGDESCTAG data object:
  286. *        int16        nvelt (no of entries )
  287. *        char        vgname[MAXVGNAMELEN]
  288. *        int16        tag[1..nvelt]        
  289. *        int16        ref[1..nvelt]        
  290. */
  291. /* ==================================================================== */
  292.  
  293. #define INT16SIZE 2
  294.  
  295. /* ==================================================================== */
  296. /* 
  297. *    vpackvg
  298. *    extracts fields from  a VGROUP struct vg and pack the fields
  299. *  into array buf in preparation for storage in the HDF file.
  300. *
  301. *  NO RETURN VALUES.
  302. */
  303.  
  304. void vpackvg (vg,buf,size)       /*@@*/
  305.  
  306. VGROUP            *vg;        /* vgroup to be saved to file */
  307. unsigned char     buf[];     /* buffer to receive the packed fields */
  308. int               *size;    /* the size of buf is returned here */
  309.  
  310. {
  311.     int              i;
  312.     unsigned     char*b, *bb;
  313.     int16            int16var;
  314.  
  315.     bb = &buf[0];
  316.  
  317.     /* save nvelt */
  318.     b= bb;
  319.     INT16WRITE(b,vg->nvelt);
  320.     bb +=INT16SIZE;
  321.  
  322.  
  323.     /* save all tags */
  324.     for(i=0;i<vg->nvelt;i++) {
  325.         b= bb;
  326.         INT16WRITE(b,vg->tag[i]);
  327.         bb +=INT16SIZE;
  328.     }
  329.  
  330.     /* save all refs */
  331.     for(i=0;i<vg->nvelt;i++) {
  332.         b= bb;
  333.         INT16WRITE(b,vg->ref[i]);
  334.         bb +=INT16SIZE;
  335.     }
  336.  
  337.     /* save the vgnamelen and vgname - omit the null */
  338.     b= bb;
  339.     int16var = strlen(vg->vgname);
  340.     INT16WRITE(b,int16var);
  341.     bb +=INT16SIZE;
  342.  
  343.     strcpy(bb,vg->vgname);
  344.     bb +=  strlen(vg->vgname) ;
  345.  
  346.     /* save the vgclasslen and vgclass- omit the null */
  347.     b= bb;
  348.     int16var = strlen(vg->vgclass);
  349.     INT16WRITE(b,int16var);
  350.     bb +=INT16SIZE;
  351.  
  352.     strcpy(bb,vg->vgclass);
  353.     bb +=  strlen(vg->vgclass) ;
  354.  
  355.     /* save the expansion tag/ref pair */
  356.     b= bb;
  357.     INT16WRITE(b,vg->extag);   /* the vg's expansion tag */
  358.     bb +=INT16SIZE;
  359.  
  360.     b= bb;
  361.     INT16WRITE(b,vg->exref);   /* the vg's expansion ref */
  362.     bb +=INT16SIZE;
  363.  
  364.     /*  save the vg's version field */
  365.     b= bb;
  366.     INT16WRITE(b,vg->version);
  367.     bb +=INT16SIZE;
  368.  
  369.     /* save the vg's more field */
  370.     b= bb;
  371.     INT16WRITE(b,vg->more);
  372.     bb +=INT16SIZE;
  373.  
  374.     if (vjv) {
  375.         sprintf(sjs,"vpackvg: vgname is [%s]\n",vg->vgname);
  376.         zj;
  377.     }
  378.  
  379.     /* returns the size of total fields saved */
  380.     *size = bb - buf + 1;
  381.  
  382.     if (vjv) {
  383.         sprintf(sjs,"#vpackvg: vg->nvelt=%d\n",vg->nvelt);
  384.         zj;
  385.     }
  386.  
  387. } /* vpackvg */
  388.  
  389. /* ==================================================================== */
  390. /*
  391. *    vunpackvg:
  392. *    Unpacks the fields from a buf (ie a VGDESCTAG data object just 
  393. *    read in from the HDF file), into a VGROUP structure vg.
  394. *
  395. *     Will first zero out vg, unpack fields, then inits as much of 
  396. *  vg as it can.
  397. *
  398. *    NO RETURN VALUES
  399. *
  400. */
  401.  
  402. void vunpackvg (vg,buf,size)          /*@@*/
  403.  
  404. VGROUP*              vg;        /* vgroup to be loaded with file data */
  405. unsigned char     buf[];     /* must contain a VGDESCTAG data object from file */
  406.  
  407. int*              size;      /* ignored, but included to look like vpackvg() */
  408.  
  409. {
  410.  
  411.     unsigned char    *b, *bb;
  412.     int                 i;
  413.     int                 int16var;
  414.  
  415.     i = *size; /* dummy, so that compiler thinks it is used  */
  416.  
  417.     bb = &buf[0];
  418.  
  419.     /* retrieve nvelt */
  420.     b = bb;
  421.     INT16READ(b,vg->nvelt);
  422.     bb+=INT16SIZE;
  423.  
  424.     /* retrieve the tags */
  425.     for (i=0;i<vg->nvelt;i++) {
  426.         b= bb;
  427.         INT16READ(b,vg->tag[i]);
  428.         bb +=INT16SIZE;
  429.     }
  430.  
  431.     /* retrieve the refs */
  432.     for (i=0;i<vg->nvelt;i++) {
  433.         b= bb;
  434.         INT16READ(b,vg->ref[i]);
  435.         bb +=INT16SIZE;
  436.     }
  437.  
  438.     /* retrieve vgname (and its len)  */
  439.     b= bb;
  440.     INT16READ(b,int16var);
  441.     bb +=INT16SIZE;
  442.  
  443.     strncpy(vg->vgname, bb, int16var);
  444.     vg->vgname[int16var] = '\0';
  445.     bb += int16var;
  446.  
  447.     if (vjv) {
  448.         sprintf(sjs,"vunpackvg: vgname is [%s]\n",vg->vgname);
  449.         zj;
  450.     }
  451.  
  452.     /* retrieve vgclass (and its len)  */
  453.     b= bb;
  454.     INT16READ(b,int16var);
  455.     bb +=INT16SIZE;
  456.  
  457.     strncpy(vg->vgclass, bb, int16var);
  458.     vg->vgclass[int16var] = '\0';
  459.     bb += int16var;
  460.  
  461.     b = bb;
  462.     INT16READ(b,vg->extag); /* retrieve the vg's expansion tag */
  463.     bb += INT16SIZE;
  464.  
  465.     b = bb;
  466.     INT16READ(b,vg->exref); /* retrieve the vg's expansion ref */
  467.     bb += INT16SIZE;
  468.  
  469.     b = bb;
  470.     INT16READ(b,vg->version); /* retrieve the vg's version field */
  471.     bb += INT16SIZE;
  472.  
  473.     b = bb;
  474.     INT16READ(b,vg->more); /* retrieve the vg's more field */
  475.     bb += INT16SIZE;
  476.  
  477.  
  478. } /* vunpackvg */
  479.  
  480.  
  481. /* ------------------------------------------------- */
  482.  
  483.  
  484. /* ==================================================================== */
  485.  
  486. /*
  487. *     Vattach:
  488. *
  489. *   attaches to an existing vgroup or creates a new vgroup.
  490. *     returns NULL if  error, else ptr to vgroup.
  491. *
  492. *    IGNORE accesstype. (but save it)  
  493. *  if vgid == -1,
  494. *      create a NEW vg if vgdir is not full.
  495. *      Also set nattach =1, nentries=0.
  496. *  if vgid +ve, 
  497. *      look in vgdir to see if already attached,
  498. *      if yes, incr nattach 
  499. *      if not, fetch from file. attach, set nattach=1, netries= val from file 
  500. *
  501. *    In any case, set marked flag to 0.
  502. */
  503.  
  504. PUBLIC VGROUP *Vattach (f, vgid, accesstype)     /*@-@*/
  505.  
  506. int         vgid;                 /* actual vgroup's vgid or -1 for new vgroup */
  507. char       *accesstype;     /* ignored */
  508. DF            *f;                 /* HDF file handle */
  509.  
  510. {
  511.     VGROUP            *vg;
  512.     int                 access,  vgpacksize;
  513.     unsigned char     vgpack[sizeof(VGROUP)];
  514.     vginstance_t    * v;
  515.     vfile_t            * vf;
  516.  
  517.  
  518.     if (f==NULL)
  519.         RTNULL("vattach:bad f");
  520.  
  521.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  522.         RTNULL ("Vattach: no such file\n");
  523.  
  524.     if      ( accesstype[0]=='R' || accesstype[0]=='r') { 
  525.         access = 'r'; 
  526.     }
  527.     else if ( accesstype[0]=='W' || accesstype[0]=='w') { 
  528.         access = 'w'; 
  529.     }
  530.     else RTNULL("Vattach: bad access type");
  531.  
  532.     if (vgid == -1) {             /******* create a NEW vg in vgdir ******/
  533.  
  534.         if (access=='r') RTNULL("Vattach: don't use r acces with new vg\n");
  535.  
  536.         /* allocate space for vg, & zero it out */
  537.         if ( (vg = (VGROUP*) DFIgetspace(sizeof(VGROUP)) ) == NULL)
  538.             RTNULL("Vattach: cannot getspace\n");
  539.         zerofill ((unsigned char*) vg,sizeof(VGROUP));
  540.  
  541.         /* initialize new vg */
  542.         vg->nvelt         = 0;
  543.         vg->vgname[0]    = '\0';
  544.         vg->f                = f;
  545.         vg->otag         = VGDESCTAG;
  546.         vg->oref            = vnewref(f);  /* create a new unique ref for it */
  547.         vg->access      = access;
  548.  
  549.         vg->marked        = 0;
  550.         vg->vgclass[0]    = '\0';
  551.         vg->extag        = 0;
  552.         vg->exref        = 0;
  553.         vg->more            = 0;
  554.         vg->version        = VSET_VERSION;
  555.  
  556.         if( vg->oref < 0)
  557.             RTNULL("Vattach: no more refs");
  558.  
  559.         /* attach new vg to file's vgtab  */
  560.         if ( NULL == (v = (vginstance_t*) DFIgetspace(sizeof(vginstance_t))))
  561.             RTNULL("Vattach: cannot getspace for vgtab \n");
  562.  
  563.         vf->vgtabtail->next = v;
  564.         vf->vgtabtail          = v;
  565.         vf->vgtabn++;
  566.         v->next                  = NULL;
  567.         v->ref       = vg->oref;
  568.         v->vg          = vg;
  569.         v->nattach    = 1;
  570.         v->nentries    = 0;
  571.  
  572.         return(vg);
  573.     }
  574.  
  575.     else {                             /******* access an EXISTING vg *********/
  576.  
  577.         if (NULL == (v= (vginstance_t*) vginstance (f,vgid)))
  578.             RTNULL("Vattach: vgid not in vgtab");
  579.  
  580.         if (v->vg != NULL) {  /* vg already attached */
  581.             v->nattach++;         /* so, just incr nattach */
  582.             return(v->vg);        /* & return that vg's ptr */
  583.  
  584.         }
  585.  
  586.         /* else vg not attached, must fetch vg from file */
  587.  
  588.         if (-1 ==  DFgetelement(f,VGDESCTAG,vgid,vgpack))
  589.             RTNULL("Vattach: vg  not in file");
  590.  
  591.         /* allocate space for vg, & zero it out */
  592.  
  593.         if (NULL== (vg =(VGROUP*) DFIgetspace(sizeof(VGROUP))) )
  594.             RTNULL("Vattach: cannot getspace\n");
  595.         zerofill((unsigned char*) vg,sizeof(VGROUP));
  596.  
  597.         /* unpack vgpack into structure vg, and init  */
  598.  
  599.         vunpackvg(vg,vgpack,&vgpacksize);
  600.         vg->f                = f;
  601.         vg->oref            = vgid;
  602.         vg->otag         = VGDESCTAG;
  603.         vg->access        = access;
  604.         vg->marked        = 0;
  605.  
  606.         /* attach vg to file's vgtab at the vg instance v */
  607.         v->vg                = vg;
  608.         v->nattach        = 1;
  609.         v->nentries = vg->nvelt;
  610.  
  611.         return(vg);
  612.     }
  613.  
  614.  
  615. } /* Vattach */
  616.  
  617. /* ==================================================================== */
  618. /* 
  619. *    Vdetach
  620. *    Detaches access to vg.    
  621. *    NO RETURN VALUES
  622. *
  623. *  if marked flag is 1, write out vg to file.
  624. *    if vg still has velts attached to it, cannot detach vg.
  625. *    decr  nattach. if (nattach is 0), free vg from vg instance.
  626. *    (check that no velts are still attached to vg before freeing)
  627. *
  628. *  if attached with read access, just return.
  629. *
  630. * after detach, set marked flag to 0.    
  631. *
  632. */
  633.  
  634. PUBLIC void Vdetach (vg)             /*@-@*/
  635.  
  636. VGROUP *vg;
  637. {
  638.  
  639.     int              i,vgpacksize;
  640.     unsigned char vgpack[sizeof(VGROUP)];
  641.     vginstance_t * v;
  642.  
  643.     if (vg==NULL) return;
  644.     if (vg->otag != VGDESCTAG) return;
  645.  
  646.     /* locate vg's index in vgtab */
  647.     if (NULL ==( v = (vginstance_t*) vginstance (vg->f,vg->oref))) {
  648.         sprintf(sjs,"@Vdetach: vg not found\n");
  649.         zj;
  650.         return;
  651.     }
  652.  
  653.     /* update vgroup to file if it has write-access */
  654.  
  655.     /* if its marked flag is 1 */
  656.     /* - OR - */
  657.     /* if that vgroup is empty */
  658.     if (vg->access == 'w') {
  659.         if ((vg->nvelt==0) || (vg->marked == 1)) {
  660.             if (vjv) {
  661.                 sprintf(sjs,"@VDETACH: added %d entries in vg..update vg to file\n",
  662.                     vg->nvelt - v->nentries);
  663.                 zj;
  664.             }
  665.             vpackvg(vg,vgpack,&vgpacksize);
  666.             if (DFputelement(vg->f,VGDESCTAG,vg->oref,vgpack,vgpacksize) == -1)
  667.                 sprintf(sjs,"@Vdetach: putelement error\n"); 
  668.             zj;
  669.             vg->marked = 0;
  670.             return;
  671.         }
  672.     }
  673.  
  674.     v->nattach--;
  675.     if (vjv) {
  676.         sprintf(sjs,"#Vdetach: nattach is now %d\n", v->nattach);
  677.         zj;
  678.     }
  679.  
  680.     if (v->nattach > 0)
  681.         return;    /* ok */
  682.  
  683.  
  684.     /* else, we can detach and remove vg from file's vgtab  */
  685.  
  686.     for (i=0;i<vg->nvelt;i++)       /* check if vg still has attached entries */
  687.         if (vg->velt[i] != NULL) {
  688.             sprintf(sjs,"@Vdetach: vg has vs %d undetached! continuing. \n",i);
  689.             zj;
  690.             break;
  691.         }
  692.  
  693.     v->vg = NULL;              /* detach vg from vgdir */
  694.  
  695.     DFIfreespace(vg);
  696.  
  697.     return; /* ok */
  698.  
  699. } /* Vdetach */
  700.  
  701.  
  702. /* ==================================================================== */
  703. /*
  704. *    Vinsert
  705. *  inserts a velt (vs or vg)  into a vg 
  706. *    RETURNS entry position within vg (0 or +ve) or -1 on error.
  707. *
  708. *    checks and prevents duplicate links.
  709. *
  710. * Since multiple files are now possible, check that both vg and velt
  711. * are from the same file. else error.
  712. */
  713.  
  714. PUBLIC int Vinsert (vg,velt)             /*@-@*/
  715.  
  716. VGROUP    *vg;
  717. VDATA     *velt;            /* (VGROUP*) or (VDATA*), doesn't matter */
  718.  
  719. {
  720.     int i;
  721.     char ss[80];
  722.  
  723.     if (vg == NULL || velt == NULL) return(FAIL);
  724.     if (vg->otag != VGDESCTAG || vg->nvelt >= MAXNVELT) return(FAIL);
  725.  
  726.     if ( (vfile_t*) Get_vfile(vg->f) != (vfile_t*) Get_vfile(velt->f) )
  727.         RTNEG("Vinsert: vg and velt not in same file\n");
  728.  
  729.     /* check in vstab  (kkk!!)  or vgtab that velt actually exist in file */
  730.  
  731.     switch (velt->otag) {
  732.     case VSDESCTAG:
  733.         if (-1 == vexistvs (vg->f,velt->oref))
  734.             RTNEG("@Vinsert vs doesn't exist\n");
  735.         break;
  736.  
  737.     case VGDESCTAG:
  738.         if (-1 == vexistvg (vg->f,velt->oref))
  739.             RTNEG("@Vinsert: vg doesn't exist\n");
  740.         break;
  741.  
  742.     default:
  743.         RTNEG("@Vinsert: unknown element\n");
  744.         break;
  745.     } /* switch */
  746.  
  747.     /* check and prevent duplicate links */
  748.     for(i=0;i<vg->nvelt;i++)
  749.         if ( (vg->tag[i] == velt->otag) && (vg->ref[i] == velt->oref) ) {
  750.             sprintf(ss,"@Vinsert: duplicate link <%d/%d>\n", 
  751.                 velt->otag,velt->oref);
  752.             RTNEG(ss);
  753.         }
  754.  
  755.     /* Finally, ok to insert */
  756.     vinsertpair ( vg, velt->otag, velt->oref);
  757.  
  758.     if (vjv) {
  759.         sprintf(sjs,"#Vinsert:inserted <%d/%d> at nvelt=%d\n",
  760.             velt->otag, velt->oref, vg->nvelt);
  761.         zj;
  762.     }
  763.  
  764.     vg->marked = 1;
  765.     return(vg->nvelt - 1);
  766.  
  767. } /* Vinsert */
  768.  
  769. /* ------------------------------------------------------------------ */
  770. /*
  771. Checks to see if the given field exists in a vdata belonging to this vgroup.
  772. If found, returns the ref of the vdata.
  773. If not found, or error, returns -1.
  774. 28-MAR-91 Jason Ng NCSA
  775. */
  776.  
  777. PUBLIC int Vflocate (vg, field)
  778. VGROUP * vg;
  779. char * field;
  780. {
  781.     int     i, s;
  782.     VDATA *vs;
  783.  
  784.     for (i=0;i<vg->nvelt;i++)  {
  785.         if (vg->tag[i] != VSDESCTAG) continue;
  786.         vs = (VDATA*) VSattach (vg->f,vg->ref[i],"r"); 
  787.         if (vs==NULL) return (-1);
  788.         s = VSfexist (vs, field);
  789.         VSdetach (vs);
  790.         if (s==1) return (vg->ref[i]); /* found. return vdata's ref */
  791.     }
  792.  
  793.     return (-1); /* field not found */
  794.  
  795. } /* Vflocate */
  796.  
  797. /* ------------------------------------------------------------------ */
  798. /*
  799. * Checks whether the given tag/ref pair already exists in the vgroup.
  800. * RETURNS 1 if exist
  801. * RETURNS 0 if not.
  802. * 28-MAR-91 Jason Ng NCSA
  803. */
  804. PUBLIC int Vinqtagref ( vg, tag, ref)
  805. VGROUP * vg;
  806. int tag, ref;
  807. {
  808.     int i;
  809.  
  810.     for (i=0; i<vg->nvelt; i++)
  811.         if ( (tag== vg->tag[i]) && (ref== vg->ref[i]) ) return (1); /* exist */
  812.  
  813.     return (0); /* does not exist */
  814.  
  815. } /* Vinqtagref */
  816.  
  817. /* ------------------------------------------------------------------ */
  818. /*
  819. * Returns the number (0 or +ve integer) of tag/ref pairs in a vgroup.
  820. * If error, returns -1.
  821. * 28-MAR-91 Jason Ng NCSA.
  822. */
  823.  
  824. PUBLIC int Vntagrefs (vg)
  825. VGROUP * vg;
  826. {
  827.     return ( (vg->otag==VGDESCTAG) ? vg->nvelt: -1);
  828. } /* Vntagrefs */
  829.  
  830. /* ------------------------------------------------------------------ */
  831. /*
  832. * Returns n tag/ref pairs from the vgroup into the caller-supplied arrays
  833. * tagrarray and refarray.
  834. * n can be any +ve number, but arrays must be this big.
  835. * RETURNS the total number of (0 or +ve #)  tag/ref pairs returned.
  836. * RETURNS -1 if error.
  837. * 28-MAR-91 Jason Ng NCSA.
  838. *
  839. * NOTE: Do not confuse with Vgettagref().
  840. *
  841. */
  842.  
  843. PUBLIC int Vgettagrefs (vg, tagarray, refarray, n)
  844. VGROUP * vg;
  845. int n;
  846. int tagarray[], refarray[];
  847.  
  848. {
  849.     int i, ntagrefs;
  850.  
  851.     if ( n <= vg->nvelt) ntagrefs = n;
  852.     else n = vg->nvelt;
  853.  
  854.     for (i=0; i<ntagrefs; i++) {
  855.         tagarray[i] = vg->tag[i];
  856.         refarray[i] = vg->ref[i];
  857.     }
  858.  
  859.     return (ntagrefs);
  860. } /* Vgettagrefs */
  861.  
  862. /* ------------------------------------------------------------------ */
  863. /*
  864. * Returns a specified tag/ref pair from the vgroup.
  865. * User specifies an index. 
  866. * RETURNS 1 if OK.
  867. * RETURNS -1 if error.
  868. * 12-MAY-91 Jason Ng NCSA.
  869. *
  870. * NOTE: Do not confuse with Vgettagrefs().
  871. *
  872. */
  873.  
  874. PUBLIC int Vgettagref (vg, which, tag, ref)
  875. VGROUP * vg;
  876. int which;
  877. int *tag, *ref; /* these are returned */
  878.  
  879. {
  880.  
  881.     if (vg==NULL) return (-1);
  882.     if (which < 0 || which > vg->nvelt-1) return (-1); /* range err */
  883.  
  884.         *tag  = vg->tag[which];
  885.         *ref  = vg->ref[which];
  886.     return (1); /* ok */
  887.  
  888. } /* Vgettagref */
  889. /* ------------------------------------------------------------------ */
  890. /*
  891. * Inserts a tag/ref pair into the attached vgroup vg.
  892. * First checks that the tag/ref is unique.
  893. * If error, returns -1 or tag/ref is not inserted.
  894. * If OK, returns the total number of tag/refs in the vgroup (a +ve integer).
  895. * 28-MAR-91 Jason Ng NCSA.
  896. */
  897.  
  898. PUBLIC int Vaddtagref ( vg, tag, ref)
  899. VGROUP * vg;
  900. int tag, ref;
  901. {
  902.     int  n;
  903.  
  904.     if (Vinqtagref (vg, tag, ref) == 1) return (-1); /* error, already exists */
  905.     n = vinsertpair (vg, tag, ref);
  906.     return (n);
  907. } /* Vaddtagref */
  908.  
  909. /* ------------------------------------------------------------------ */
  910. /*
  911. * Inserts a tag/ref pair into the attached vgroup vg.
  912. * Does not check for errors. 
  913. * Returns the total number of tag/refs in theat vgroup.
  914. */
  915.  
  916. int vinsertpair ( vg, tag, ref)
  917. VGROUP    * vg;
  918. int        tag, ref;
  919. {
  920.     vg->velt[vg->nvelt]  = NULL;
  921.     vg->tag[vg->nvelt]   = tag;
  922.     vg->ref[vg->nvelt]   = ref;
  923.     vg->nvelt ++;
  924.  
  925.     vg->marked = 1;
  926.     return (vg->nvelt);
  927. }
  928.  
  929. /* ==================================================================== */
  930. /* 
  931. *     Ventries
  932. *    returns the no of entries (+ve integer) in the vgroup vgid.
  933. *  vgid must be an actual id
  934. *  RETURNS -1 if error
  935. *
  936. *  undocumented
  937. *
  938. */
  939.  
  940. int Ventries (f,vgid)                 /*@@*/
  941.  
  942. DF* f;
  943. int vgid;
  944. {
  945.     unsigned char vgpack[sizeof(VGROUP)];
  946.     VGROUP vg;
  947.     int    vgpacksize;
  948.  
  949.     if (vgid < 1) return(FAIL);
  950.     if ( DFgetelement(f,VGDESCTAG ,vgid,vgpack) == -1) {
  951.         sprintf(sjs,"@Ventries: cannot get vg from file\n");
  952.         zj;
  953.         return(FAIL);
  954.     }
  955.  
  956.     vunpackvg(&vg,vgpack,&vgpacksize);
  957.     return(vg.nvelt);
  958.  
  959. } /* Ventries */
  960.  
  961.  
  962. /* ==================================================================== */
  963. /*
  964. *    Vsetname
  965. *     gives a name to the VGROUP vg.
  966. *
  967. * NO RETURN VALUES.
  968. *
  969. *    truncates to max length of VGNAMELENMAX 
  970. */
  971.  
  972. PUBLIC void Vsetname (vg, vgname)         /*@-@*/
  973.  
  974. VGROUP    *vg;
  975. char        *vgname;
  976.  
  977. {
  978.     if (vg == NULL) return;
  979.     if ( strlen(vgname) > VGNAMELENMAX) {
  980.         strncpy(vg->vgname, vgname,VGNAMELENMAX);
  981.         vg->vgname[VGNAMELENMAX]='\0';
  982.     }
  983.     else
  984.         strcpy(vg->vgname, vgname);
  985.     vg->marked = 1;
  986.     return;
  987.  
  988. } /* Vsetname */
  989.  
  990. /* ==================================================================== */
  991. /*
  992. *    Vsetclass
  993. *     assigns a class name to the VGROUP vg.
  994. *
  995. * NO RETURN VALUES.
  996. *
  997. *    truncates to max length of VGNAMELENMAX 
  998. */
  999.  
  1000. PUBLIC void Vsetclass (vg, vgclass)         /*@-@*/
  1001.  
  1002. VGROUP    *vg;
  1003. char        *vgclass;
  1004.  
  1005. {
  1006.     if (vg == NULL) return;
  1007.     if ( strlen(vgclass) > VGNAMELENMAX) {
  1008.         strncpy(vg->vgclass, vgclass,VGNAMELENMAX);
  1009.         vg->vgclass[VGNAMELENMAX]='\0';
  1010.     }
  1011.     else
  1012.         strcpy(vg->vgclass, vgclass);
  1013.     vg->marked = 1;
  1014.     return;
  1015.  
  1016. } /* Vsetclass*/
  1017.  
  1018.  
  1019. /* ======================================================= */
  1020. /*
  1021. *     Visvg
  1022. *    tests if an entry in the vgroup vg is a VGROUP, given the entry's id. 
  1023. *
  1024. *    RETURNS 1 if so
  1025. *    RETURNS 0 if not, or if error
  1026. *
  1027. */
  1028.  
  1029. PUBLIC int Visvg (vg,id)           /*@-@*/
  1030.  
  1031. VGROUP    *vg;
  1032. int         id;        /* valid id of the entry in question */
  1033. {
  1034.     int     i;
  1035.  
  1036.     for(i=0;i<vg->nvelt;i++)
  1037.         if (vg->ref[i] == id   &&      /* if the ids match, */
  1038.         vg->tag[i]==VGDESCTAG)     /* and it is a vgroup */
  1039.             return (1);
  1040.  
  1041.     return (0);
  1042.  
  1043. } /* Visvg */
  1044.  
  1045. /* ======================================================= */
  1046. /* 
  1047. *    Vgetid
  1048. *    
  1049. *    Given a vgroup's id, returns the next vgroup's id in the file f .
  1050. *    The call Vgetid(f,-1) returns the id of the FIRST vgroup in the file. 
  1051. *
  1052. *    RETURNS -1 if error
  1053. *    RETURNS the next vgroup's id (0 or +ve integer).
  1054. *
  1055. *    This id is actually the "ref" of the vgroup "tag/ref".
  1056. */
  1057.  
  1058. PUBLIC int Vgetid (f,vgid)               /*@-@*/
  1059.  
  1060. int     vgid;                    /* current vgid */
  1061. DF*     f;                        /* HDF file handle */
  1062.  
  1063. {
  1064.     vginstance_t * v;
  1065.     vfile_t        * vf;
  1066.  
  1067.     if ( vgid < -1) return(FAIL);
  1068.  
  1069.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  1070.         RTNEG ("Vgetid: no such file\n");
  1071.  
  1072.     if (vjv) {
  1073.         sprintf(sjs,"#Vgetid:vgtabn= %d vgid=%d\n",vf->vgtabn,vgid);
  1074.         zj;
  1075.     }
  1076.  
  1077.     if (vgid == -1) {
  1078.         if (NULL == vf->vgtab.next)
  1079.             return (-1);
  1080.         else
  1081.             return( (vf->vgtab.next)->ref); /* rets 1st vgroup's ref */
  1082.     }
  1083.  
  1084.     /* look in vgtab for vgid */
  1085.     v = (vf->vgtab).next;
  1086.     while(NULL != v) {
  1087.         if(v->ref == vgid) break;
  1088.         v = v->next;
  1089.     }
  1090.     if (v==NULL)
  1091.         return (FAIL); /* none found */
  1092.     else
  1093.         if( v->next ==NULL)
  1094.             return (FAIL); /* this is the last vg, no more after it */
  1095.         else
  1096.             return((v->next)->ref); /* success, return the next vg's ref */
  1097.  
  1098. } /* Vgetid */
  1099.  
  1100.  
  1101. /* ================================================================= */
  1102. /*
  1103. *    Vgetnext
  1104. *
  1105. *    Given the id of an entry from a vgroup vg, looks in vg for the next
  1106. *    entry after it, and returns its id.
  1107. *    The call Vgetnext (vg,-1) returns the id of the FIRST entry in the vgroup.
  1108. *
  1109. *  Vgetnext will look at only VSET elements in the vgroup.
  1110. *  To look at all links in a vgroup, use Vgettagrefs instead.
  1111. *
  1112. *    RETURNS -1 if error
  1113. *    RETURNS the id of the next entry( 0 or +ve integer)  in the vgroup.
  1114. *
  1115. *    This id is actually the "ref" of the entry's "tag/ref".
  1116. *
  1117. */
  1118.  
  1119. PUBLIC int Vgetnext (vg,id)           /*@-@*/
  1120.  
  1121. VGROUP    *vg;
  1122. int         id;                    /* actual id of an entry in the vgroup vg */
  1123. {
  1124.     int     i;
  1125.  
  1126.     if (id < -1) return(FAIL);
  1127.     if (vg == NULL) return(FAIL);
  1128.     if (vg->otag != VGDESCTAG) return(FAIL);
  1129.  
  1130.     if (vjv) {
  1131.         sprintf(sjs,"#Vgetnext:vg->nvelt is %d\n",vg->nvelt);
  1132.         zj;
  1133.     }
  1134.     if (vg->nvelt  == 0) return(FAIL);             /* nothing in vg */
  1135.  
  1136.     if (id == -1) {
  1137.         if ((vg->tag[0]==VGDESCTAG) || (vg->tag[0]==VSDESCTAG)) 
  1138.                 return(vg->ref[0]);         /* id of first entry */
  1139.         }
  1140.     
  1141.     /* look in vg for id */
  1142.     for(i=0;i<vg->nvelt;i++) 
  1143.         if ((vg->tag[i]==VGDESCTAG) || (vg->tag[i]==VSDESCTAG)) {
  1144.             if(vg->ref[i] == id) {
  1145.                 if (i == (vg->nvelt - 1) )
  1146.                     return(FAIL);
  1147.                 else  {
  1148.                     if ((vg->tag[i+1]==VGDESCTAG) ||
  1149.                          (vg->tag[i+1]==VSDESCTAG)) 
  1150.                         return(vg->ref[i+1]);        /* return the id of next entry */
  1151.                     else  return (-1); 
  1152.                     }
  1153.             }
  1154.         }
  1155.  
  1156.     return (FAIL);
  1157.  
  1158. } /* Vgetnext  */
  1159.  
  1160. /* ================================================================= */
  1161. /*
  1162. *    Vgetname
  1163. *    returns the vgroup's name
  1164. *
  1165. */
  1166.  
  1167. PUBLIC void Vgetname (vg, vgname)          /*@-@*/
  1168.  
  1169. VGROUP    *vg;
  1170. char        *vgname;                /* its name is returned in this var */
  1171. {
  1172.     if(vg != NULL) strcpy(vgname, vg->vgname);
  1173.     return;
  1174.  
  1175. } /* Vgetname */
  1176. /* ================================================================= */
  1177. /*
  1178. *    Vgetclass
  1179. *    returns the vgroup's class name 
  1180. *
  1181. */
  1182.  
  1183. PUBLIC void Vgetclass (vg, vgclass)          /*@-@*/
  1184.  
  1185. VGROUP    *vg;
  1186. char        *vgclass;                /* its class name is returned in this var */
  1187. {
  1188.     if(vg != NULL) strcpy(vgclass, vg->vgclass);
  1189.     return;
  1190.  
  1191. } /* Vgetclass*/
  1192.  
  1193. /* ================================================================= */
  1194. /*
  1195. *    Vinquire
  1196. *
  1197. *    General inquiry routine for VGROUP. 
  1198. *
  1199. *    output parameters:
  1200. *            nentries - no of entries in the vgroup
  1201. *            vgname    - the vgroup's name
  1202. *
  1203. *    RETURNS -1 if error
  1204. *    RETURNS 1 if ok
  1205. *
  1206. */
  1207.  
  1208. PUBLIC int Vinquire (vg, nentries, vgname)     /*@-@*/
  1209.  
  1210. VGROUP    *vg;
  1211. char        *vgname;
  1212. int         *nentries;
  1213. {
  1214.     if (vg == NULL) return(FAIL);
  1215.     if (vg->otag != VGDESCTAG) return(FAIL);
  1216.  
  1217.     strcpy(vgname, vg->vgname);
  1218.     *nentries = vg->nvelt;
  1219.  
  1220.     return(1); /* ok */
  1221.  
  1222. } /* Vinquire */
  1223.  
  1224. /* ================================================================= */
  1225.  
  1226.